{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## _*Qiskit Chemistry, H2O ground state computation*_\n",
    "\n",
    "This notebook demonstrates how to use Qiskit Chemistry to compute the ground state energy of a water (H2O) molecule using VQE and UCCSD.\n",
    "\n",
    "While the molecule has been input below to the driver in xyz format, the Z-matrix format is also support. H2O in Z-matrix format would look like this \n",
    "```\n",
    "H; O 1 1.08; H 2 1.08 1 104.5\n",
    "```\n",
    "and is convenient when the goal is to change bond angle, or plot the energy changing distance(s) while preserving the angle.\n",
    "\n",
    "This notebook has been written to use the PYSCF chemistry driver. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import BasicAer\n",
    "\n",
    "from qiskit.aqua import QuantumInstance\n",
    "from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver\n",
    "from qiskit.aqua.components.optimizers import SLSQP\n",
    "\n",
    "from qiskit.chemistry.drivers import PySCFDriver, UnitsType\n",
    "from qiskit.chemistry.core import Hamiltonian, TransformationType, QubitMappingType \n",
    "from qiskit.chemistry.components.variational_forms import UCCSD\n",
    "from qiskit.chemistry.components.initial_states import HartreeFock"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we create and run a driver to produce our molecule object. The molecule object holds data from the drivers in a common way so it can then be used independently of which specific driver created it.\n",
    "\n",
    "And let's print some of fields it has. You can refer to qiskit.aqua.qmolecule.py for more information or look at the API documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hartree-Fock energy: -74.9629466565383\n",
      "Nuclear repulsion energy: 9.193913160623385\n",
      "Number of molecular orbitals: 7\n",
      "Number of alpha electrons: 5\n",
      "Number of beta electrons: 5\n"
     ]
    }
   ],
   "source": [
    "driver = PySCFDriver(atom='O 0.0 0.0 0.0; H 0.757 0.586 0.0; H -0.757 0.586 0.0',\n",
    "                     unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g')\n",
    "molecule = driver.run()\n",
    "\n",
    "print('Hartree-Fock energy: {}'.format(molecule.hf_energy))\n",
    "print('Nuclear repulsion energy: {}'.format(molecule.nuclear_repulsion_energy))\n",
    "print('Number of molecular orbitals: {}'.format(molecule.num_orbitals))\n",
    "print('Number of alpha electrons: {}'.format(molecule.num_alpha))\n",
    "print('Number of beta electrons: {}'.format(molecule.num_beta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now need to create a qubit operator as input to compute the ground state energy. The Hamilitonian object can be used. This wraps a `FermionicOperator` class, which can be used directly but entails more steps. Other tutorials here show FermionicOperator being used.\n",
    "\n",
    "The Hamiltonian class not only gives us a qubit operator for the main Hamiltonian but also auxilliary operators including dipole operators and others to measure spin and num particles. The algorithm, if it supports aux_ops, which ExactEignesolver and VQE both do, will evaluate these at the ground state where the minimum energy is found."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Electronic Hamiltonian: Representation: paulis, qubits: 10, size: 551\n"
     ]
    }
   ],
   "source": [
    "core = Hamiltonian(transformation=TransformationType.FULL, qubit_mapping=QubitMappingType.PARITY, \n",
    "                   two_qubit_reduction=True, freeze_core=True)\n",
    "qubit_op, aux_ops = core.run(molecule)\n",
    "\n",
    "print(qubit_op)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now pass these to the NumPyMinimumEigensolver and run it to produce a result. This result will include the computed electronic part of the ground state energy. We can pass this result back to the Hamiltonian object from above and it will combine it with values it stored such as the frozen core energy to form a complete result for the molecule. As can be seen this matches the result from above.\n",
    "\n",
    "Note: the num particles printed here is that which is observed from the spin operator that is in the aux_ops. It says 8 which matches what we expect; the molecule has 10 (5 alpha and 5 beta) but the operator was left with 8 after we took away 2 from freezing the core. The molecule has a core_orbitals property which lists the orbitals comprising the core ones that can be frozen so we can easily figure how many electrons that is (2 per orbital in that list)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "=== GROUND STATE ENERGY ===\n",
      " \n",
      "* Electronic ground state energy (Hartree): -84.206272446428\n",
      "  - computed part:      -23.544497240436\n",
      "  - frozen energy part: -60.661775205992\n",
      "  - particle hole part: 0.0\n",
      "~ Nuclear repulsion energy (Hartree): 9.193913160623\n",
      "> Total ground state energy (Hartree): -75.012359285805\n",
      "  Measured:: # Particles: 8.000 S: 0.000 S^2: 0.000 M: 0.00000\n",
      " \n",
      "=== DIPOLE MOMENT ===\n",
      " \n",
      "* Electronic dipole moment (a.u.): [0.0  1.57867263  0.0]\n",
      "  - computed part:      [0.0  1.57778798  0.0]\n",
      "  - frozen energy part: [0.0  0.00088465  0.0]\n",
      "  - particle hole part: [0.0  0.0  0.0]\n",
      "~ Nuclear dipole moment (a.u.): [0.0  2.21475902  0.0]\n",
      "> Dipole moment (a.u.): [0.0  0.63608639  0.0]  Total: 0.63608639\n",
      "               (debye): [0.0  1.61677018  0.0]  Total: 1.61677018\n"
     ]
    }
   ],
   "source": [
    "ee = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)\n",
    "algo_result = ee.run()\n",
    "result = core.process_algorithm_result(algo_result)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using VQE\n",
    "\n",
    "Here we will start with the qubit operator that we computed above. We need to setup an optimizer, variational form and initial state for use with VQE.\n",
    "\n",
    "The variational form and UCCSD are a little more complex since they need information about numbers of orbitals and numbers of electrons, as well as what qubit mapping etc was used for the qubit operator. However we have some help from the Hamiltonian class that we can use. \n",
    "\n",
    "Note: If you use FermionicOperator directly to make a qubit operator then you need to keep track of electrons removed etc. The molecule object from the driver has the original values but if you freeze out orbitals then the electrons remaining in the operator is what is required."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ground state energy: -75.01225859234138\n",
      "=== GROUND STATE ENERGY ===\n",
      " \n",
      "* Electronic ground state energy (Hartree): -84.206171752965\n",
      "  - computed part:      -23.544396546972\n",
      "  - frozen energy part: -60.661775205992\n",
      "  - particle hole part: 0.0\n",
      "~ Nuclear repulsion energy (Hartree): 9.193913160623\n",
      "> Total ground state energy (Hartree): -75.012258592341\n",
      "Actual VQE evaluations taken: 666\n"
     ]
    }
   ],
   "source": [
    "init_state = HartreeFock(num_orbitals=core._molecule_info['num_orbitals'],\n",
    "                         num_particles=core._molecule_info['num_particles'],\n",
    "                         qubit_mapping=core._qubit_mapping,\n",
    "                         two_qubit_reduction=core._two_qubit_reduction)\n",
    "\n",
    "var_form = UCCSD(num_orbitals=core._molecule_info['num_orbitals'], \n",
    "                 num_particles=core._molecule_info['num_particles'],\n",
    "                 qubit_mapping=core._qubit_mapping,\n",
    "                 two_qubit_reduction=core._two_qubit_reduction, \n",
    "                 initial_state=init_state)\n",
    "\n",
    "optimizer = SLSQP(maxiter=2500)\n",
    "\n",
    "# setup backend on which we will run\n",
    "backend = BasicAer.get_backend('statevector_simulator')\n",
    "quantum_instance = QuantumInstance(backend=backend)\n",
    "\n",
    "vqe = VQE(qubit_op, var_form, optimizer)\n",
    "algo_result = vqe.run(quantum_instance)\n",
    "result = core.process_algorithm_result(algo_result)\n",
    "\n",
    "print('Ground state energy: {}'.format(result.energy))\n",
    "print(result)\n",
    "print('Actual VQE evaluations taken: {}'.format(algo_result.optimizer_evals))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Z-matrix format\n",
    "\n",
    "Z-matrix was mentioned in the introduction. Lets show it in use in a quick final example here. We'll use NumPyMinimumEigensolver as the goal here is just to show the technique. We will keep the bond angle between the Hydrogen atoms and Oxygen constant while varying the interatomic distance of one the Hydrogen atoms. This is simple to do in Z-matrix format, though can of course be done using xyz format but that needs more work to compute the coordinates each time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pylab\n",
    "\n",
    "h2o = 'H; O 1 1.08; H 2 {} 1 104.5'\n",
    "\n",
    "distances = [x * 0.01 + 1.00 for x in range(17)]\n",
    "energies = np.empty(len(distances))\n",
    "\n",
    "for i, distance in enumerate(distances):\n",
    "    driver = PySCFDriver(h2o.format(distance), basis='sto3g')\n",
    "    qmolecule = driver.run()\n",
    "    operator =  Hamiltonian(freeze_core=True)\n",
    "    qubit_op, aux_ops = operator.run(qmolecule)\n",
    "    result = NumPyMinimumEigensolver(qubit_op).run()\n",
    "    result = operator.process_algorithm_result(result)\n",
    "    energies[i] = result.energy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ0AAAEWCAYAAAC9qEq5AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nO3dd3yV5f3/8debhL2XbARURJaMAGpdVbSuVtyjKiqu1jr6q61Y2+/Xr63VWrWttZVaB7gQ92itCq7aikLCFJANMgIEIoSVEJLP74/7ij3GkwVJ7ozP8/E4j9znvu7xuc85OZ9zX9d1X7fMDOecc646NIg7AOecc/WHJx3nnHPVxpOOc865auNJxznnXLXxpOOcc67aeNJxzjlXbTzpuNhIMkkHV+H2e4V9pFbVPlzpJF0u6d8Jz3dI6hNnTDXF/rwWVf2/U5U86dRSklZJGl1s3lf/4JIaS3pM0mpJ2yXNkXRqseXbSHpY0gZJuyTNl3RFdR6H+zpJEyX9uti8fU6eko6XtLbyItw/ZtbCzFaUtkxNi7mqlOe1qIv8F2DdlQqsAY4DvgBOA56XNMjMVklqBEwDNgFHAmuBE4FJktqa2QMxxe1cnSYp1cz2xh1HXPxMp44ys51mdoeZrTKzQjP7O7ASGB4WuRToCZxnZivNLN/M3gJuBO6U1CrZdsMv7h9KWhrOoH4l6SBJH0vKkfR8SGhFy18taZmkbEmvS+pawnYbS7pP0heSNkqaIKlpQvmZ4WwtR9JySaeE+V8745N0h6SnS9hH63D2lylpnaRfS0opz+spqWuIPzscz9XF9vm8pCfDa7JAUlqxdV+SlCVppaQby7PP8pJ0haRFYd8rJF0b5jcH/gl0DVU5O0IsjSX9QdL68PiDpMZhneMlrZX0M0mbwms1RtJpkpaE4/95KbG0D69TjqQZwEHFyr+qFgrbXBjiXifpllJiHilpuqStIaaHin3OTNJ14XO5VdKfJSmh/OqE12ihpGFhfrneG0mjFNUIpCTMO0vSvDBdnviul7QUWJrktSjr8//TsN31kq4s/RNRw5mZP2rhA1gFjC4273Lg3yUs3wnIBfqF588Bk5IslwrsBb5TwnYMeA1oBQwA8oB3gT5Aa2AhMDYsewKwGRgGNAb+BPyr2LYODtO/B14H2gEtgTeAu0PZSGAbcBLRD6VuCcfxtdcBuAN4Okz3CvtIDc9fAf4KNAcOAGYA15bz9f4X8BegCTAEyAJOSNhnLtHZZApwN/BJKGsAZAD/AzQKr9OKUl7ficCvi8372nEkWed0oi93EZ3Z7gKGhbLjgbXFlr8T+CS8Bh2Bj4FfJSy/N8TbELg6HOuz4X0ZAOwGepcQy3PA8+E1HgisI+EzWew9zwSOCdNty4h5OHAE0eezF7AIuLnYdv8OtCH6MZUFnBLKzgtxjAiv0cHAgfvw3iwHTkp4/gIwvgLxTSX6fDet4Of/FGBjeD2bh/fiq3Vr2yP2APyxj29c9GW7A9ia8NhFkqQTvjymAX9NmDcNuKeEbW8Avl9CmQHfSnieAdya8Px+4A9h+jHg3oSyFkA+0CthWweHL4KdwEEJyx4JrAzTfwV+X8rrUGbSIUq6eUX/8KH8IuD9crzWPYACoGXCvLuBiQn7nJZQ1h/YHaZHAV8U295twBMl7GsiUQJLfF9zKCXpJNnGq8BNYfp4vvkFvhw4LeH5d4BVCcvvBlLC85Zh36OKvedjkuw3Jby//RLm/YaSk84XwLVAq2Lb+UbMSfZ1M/BKse0enfD8ef6bEN4uej2KbaOi782vgccTXpedwIEViO+EJP9L5fn8P07C/yrQl1qcdLx6rXYbY2Ztih7AD4svIKkB8BSwB/hRQtFmoEuS5VOBDqG8JBsTpncned4iTHcFVhcVmNkOYAvRmUqijkAzICNUT2wF3grzIfrSX15KPOVxIFHyzUzYx1+Jfu2XpSuQbWbbE+at5uvHsSFhehfQJLyWBxJVFW1N2O/PiZJgSe4r9r4OLi04SadK+iRUfW0lOuPqUMbxrE54vjrMK7LFzArC9O7wt6T3OFFH/tuWmLjtkpwTYl0t6UNJR5a0oKS+kv4eqrhyiJJZ8WMs/h4UxVjS56ei782zwNmhKvJsYJaZra5AfGtIrqzPf1fK/5rWeJ506rBQp/0Y0T/ROWaWn1A8DTg11KEnOofojOCTSghhPdE/dlE8zYH2RFUdiTYTfZENSPiybW1mRV8aayjWNpBgJ9E/bJHOJSy3hui4OiTso5WZDSjncbST1DJhXs8kx1HSflcmJhEza2lmp5Vj3TKFL8CXgPuATiFJvUn06xmiX8TFfe19ITqW9ZUQThZR1VyPYttOysxmmtmZRIn/VaKzE0ge88PA58AhZtaKKDkoyXLJlPT5qdB7Y2YLib7wTwUuJkpCFYmvpCH9y/r8Z1LO17Q28KRTtz0MHAZ818x2Fyt7iqjH2guKuuQ2lPQd4EHgDjPbVgn7nwxcIWlI+HL8DfCpma1KXMjMCoG/Ab+XdACApG4hHogS5xWSTpTUIJT1C2VzgAtD/GnAuckCMbNM4B3gfkmtwnYOknRc2F9Rt+ReSdZdQ9TucbekJpIGA+OApB0WipkBbJd0q6SmklIkDZQ0ohzrlkcjovayLGCvom7xJyeUbwTaS2qdMG8y8AtJHSV1IGrTKM+xlCqcHb0M3CGpmaT+wNhky0pqJOn7klqHH0M5QGEpMbcMy+wI7/0PKhDao8AtkoYrcrCkA9m39+ZZ4CbgWKI2nf2Orxyf/+eByyX1l9QM+N/ybrsm8qRTR4V/qmuJGr036L89gb4PYGZ5wGiiX3ufEv3DPADcbma/q4wYzGwa8EuiX+KZRL82Lyxh8VuBZcAnoXpiGnBo2M4M4AqixtZtwIf895f6L8N2vwT+j6//+izuMqIv6YVh+Rf5bxVjD6JfsSWdvVxE1Ea0nqhDwv+G4ytV+CI+g+h9WEn0q/ZRok4X+y1U+d1I9MX0JdEv8NcTyj8nSjIrQtVNV6K2iXRgHjAfmBXmVYYfEVVrbSBqn3qilGUvBVaF9/s6oOizmSzmW8KxbSf6gp5S3oDM7AXgLqLPxnais6p2+/jeTCbqrPGemSVWQe9zfEFpn/9/An8A3gvLvFfBbdcoCg1TztVrkn4BZJnZX+OOxbm6zJOOc865ahNL9ZqkKYou9Juj6OK+OWF+L0m7E8omlLB+O0lTFV0INlVS2zBfkh5UdPHePIULwEJZT0nvKLpAbGGyunvnnHNVK5ZhcMzsgqJpSfcT1dMXWW5mQ8rYxHjgXTO7R9L48PxWol4lh4THKKKG9FFhnSeBu8xsqqQW/LfR0jnnXDWJtSNB6NJ7PlHjXEWcCUwK05OAMQnzn7TIJ0AbSV1CL5pUM5sK0fUiZrZr/4/AOedcRcQ94OcxwEYzW5owr7ek2US9qX5hZh8lWa9T6AILUS+Zoou5uvH1i6jWhnndga2SXgZ6E/UMGZ9wAVyJOnToYL169arAITnnXP2WkZGx2cw6JiursqQjaRrJL9S73cxeC9MX8fWznEygp5ltkTQceFXSADPLKWk/ZmaSyuoNkUqU4IYSDb0xhWicssdKiP0a4BqAnj17kp6eXsbmnXPOFZFU4qgJVZZ0zGx0aeWKhgg5m/+Oelx07UhemM6QtJxonKHi3/obJXUxs0xJXYiG54foGovEK3e7h3mpwBwL966Q9CrR4HxJk46ZPQI8ApCWlubd+5xzrpLE2aYzGvjczL66WVO4QjolTPch6hCQ7CZHr/PfK53HEo16XDT/stCL7QhgW6iGm0nUvlN0uncC0QWCzjnnqlGcSedCvtmB4FhgXuhC/SJwnZllA0h6VP+9R8k9wEmK7k0xOjyHaMypFURX7f6NMABmaLu5BXhX0nyiMZH+VlUH5pxzLjm/OLQMaWlp5m06zjlXfpIyzCwtWZmPveacc67aeNJxzjlXbTzpOOecqzaedJxzzn3NjJXZPPbvlVRFm78nHeecc1/ZvCOPGybP4ulPVrM7v8xBWyrMk45zzjkACguNH0+Zw5e78vnzxcNo1qjyxw/wpOOccw6Ahz9czkdLN3PHdwfQv2urKtmHJx3nnHN8smIL97+zmO8d3pWLRvYoe4V95EnHOefquc078rhx8mx6tW/Ob84eRHTXmaoR960NnHPOxaioHWfb7nwmXTmSFo2rNi140nHOuXrsz+8v46Olm7n77EEc1qVq2nESefWac87VU9OXb+H305YwZkhXLhxRde04iTzpOOdcPZS1PY8bn5tNrw7Nueusqm3HSeTVa845V88UhHacnN35PHnlSJpXcTtOIk86zjlXz/z5/WX8e9lmfntO9bTjJPLqNeecq0c+Xr6ZP0xbwllDu3F+WvW04yTypOOcc/VE1vY8bnpuDr07NOfXYwZWWztOIq9ec865eqCg0Lh5ymy25+bz9LhR1dqOk8iTjnPO1QMPvbeM/yzbwr3nDObQzi1ji8Or15xzro77eNlm/vDuEs4e2o3z0rrHGosnHeecq8M2bc/lxufmcFDHFvz6rHjacRJ59ZpzztVRBYXGzc/NYUdePs9cNapK7o9TUfFH4Jxzrkr86b2lfLx8C/eeG287TiKvXnPOuTroP8s288d3l3LOsO6xXI9TEk86zjlXx2zanstNoR3nV2MGxB3O18SWdCRNkTQnPFZJmhPm95K0O6FsQgnrt5M0VdLS8LdtmC9JD0paJmmepGEJ69wraYGkRWGZeFvUnHOukhUUGjdNnsPOvL385fvDakQ7TqLYko6ZXWBmQ8xsCPAS8HJC8fKiMjO7roRNjAfeNbNDgHfDc4BTgUPC4xrgYQBJRwHfAgYDA4ERwHGVfFjOORerP767lOkrtvCrMQPp26lmtOMkir16LZxtnA9MruCqZwKTwvQkYEzC/Cct8gnQRlIXwIAmQCOgMdAQ2Lif4TvnXI3x76Wb+dN7Szl3eHfOHR7v9TgliT3pAMcAG81sacK83pJmS/pQ0jElrNfJzDLD9AagU5juBqxJWG4t0M3MpgPvA5nh8baZLUq2YUnXSEqXlJ6VlbWPh+Wcc9VnU04uN0+ZzcEdW3DnmTWrHSdRlVb2SZoGdE5SdLuZvRamL+LrZzmZQE8z2yJpOPCqpAFmllPSfszMJFkZsRwMHAYUpf+pko4xs4+SbO8R4BGAtLS0UrfrnHNxyy8o5EfPzmZnXgGTr6557TiJqjQyMxtdWrmkVOBsYHjCOnlAXpjOkLQc6AukF1t9o6QuZpYZqs82hfnrgMT+gd3DvEuAT8xsR9j3P4EjgW8kHeecq01+8+YiZqzK5o8XDuGQGtiOkyju6rXRwOdmtrZohqSOklLCdB+iDgErkqz7OjA2TI8FXkuYf1noxXYEsC1Uw30BHCcpVVJDok4ESavXnHOutnh19jqe+M8qrvxWb84c0i3ucMoUd9K5kG92IDgWmBe6UL8IXGdm2QCSHpWUFpa7BzhJ0lKi5HVPmP8mUZJaBvwN+GGY/yKwHJgPzAXmmtkbVXJUzjlXDRas38b4l+cxqnc7bjutX9zhlIvMvMmiNGlpaZaeXrxmzznn4rV11x6++9C/yd9rvHHD0XRs2TjukL4iKcPM0pKV1dzWJuecc0kVFBo3PjeHjdvymHLtETUq4ZTFk45zztUyf5i2hH8tyeI3Zw1iaM+2cYdTIXG36TjnnKuAtxds4E/vLePCET24eFTPuMOpME86zjlXSyzP2sFPnp/L4d1bc8f3au4FoKXxpOOcc7XAjry9XPtUBo1TG/DwJcNp0jAl7pD2ibfpOOdcDWdm/PSFuazcvJOnxo2ka5umcYe0z/xMxznnargJH67gn59t4LZT+3HUQR3iDme/eNJxzrka7KOlWfzu7c/57uFdGXd077jD2W+edJxzroZak72LGyfP5pADWvLbcwZRF+476UnHOedqoNz8Aq57OoO9hcZfLx1eo0eOroi6cRTOOVeHmBk/f2U+CzNzeGxsGr06NI87pErjZzrOOVfDPP3Jal6etY6bT+zLCf06lb1CLeJJxznnapD0Vdn83xsLObHfAdxwwsFxh1PpPOk451wNsSknlx88M4vubZvywAVDaNCg9nccKM7bdJxzrgbYs7eQHz4zi515e3l63ChaN20Yd0hVwpOOc87VAHf9YyHpq7/koYuHcmjnmn3L6f3h1WvOORezlzLWMmn6aq45tg9nDO4adzhVypOOc87F6LN12/j5K/M56qD2/Ow7h8YdTpXzpOOcczH5cucern0qg/bNG/Gni4aSmlL3v5K9Tcc552KQX1DI9c/OImtHHi9edyTtW9SeW07vj7qfVp1zroYxM/739QV8vHwLd581iMHd28QdUrXxpOOcc9Vs0serePbTL/jB8QdxzvDucYdTrTzpOOdcNfpg8Sbu/PtCTu7fiZ+eXPc7DhTnScc556rJ0o3bueHZ2fTr3Irf19ERB8riScc556pB9s49jJuUTpNGKTw6No3mjetnP65Yko6kKZLmhMcqSXPC/F6SdieUTShh/XaSpkpaGv62DfP7SZouKU/SLcXWOUXSYknLJI2v+qN0zrnInr2FXPdUBhtzcvnbZWl0bdM07pBiE0uqNbMLiqYl3Q9sSyhebmZDytjEeOBdM7snJJDxwK1ANnAjMCZxYUkpwJ+Bk4C1wExJr5vZwv0+GOecK4WZcfsr85mxKpsHLxrKkB71p6daMrFWrym69+r5wOQKrnomMClMTyIkGTPbZGYzgfxiy48ElpnZCjPbAzwXtuGcc1Xqbx+t4IWMtdx44iF87/C6PcRNecTdpnMMsNHMlibM6y1ptqQPJR1TwnqdzCwzTG8AyrrLUTdgTcLztWFeUpKukZQuKT0rK6uMTTvnXHLTFm7k7n9+zumDu3DziYfEHU6NUGXVa5KmAZ2TFN1uZq+F6Yv4+llOJtDTzLZIGg68KmmAmeWUtB8zM0lWaYFH23wEeAQgLS2tUrftnKsfFmXmcNNzsxnUrTX3nXt4veyplkyVJR0zG11auaRU4GxgeMI6eUBemM6QtBzoC6QXW32jpC5mlimpC7CpjHDWAT0SnncP85xzrtJlbc/jqknptGiSyt8uS6Npo5S4Q6ox4qxeGw18bmZri2ZI6hga/ZHUBzgEWJFk3deBsWF6LPBakmUSzQQOkdRbUiPgwrAN55yrVLn5BVz7VDpbdubx6GUj6NSqSdwh1ShxdhS/kG92IDgWuFNSPlAIXGdm2QCSHgUmmFk6cA/wvKRxwGqizghI6kx0VtQKKJR0M9DfzHIk/Qh4G0gBHjezBVV+hM65esXMuO3l+cz6YisPf38Yg7q3jjukGkdm3mRRmrS0NEtPL16755xz3/Tn95fxu7cXc8vJffnRCfW344CkDDNLS1YWd+8155yrE976LJPfvb2YMUO6cv23D447nBrLk45zzu2nz9Zt48dT5jK0ZxvuOWcw0SWILhlPOs45tx825uRy1aR02jZryCOXptGkofdUK039HHHOOecqwe49BVz9ZDo5ufm89IOj6Niyftz9c3940nHOuX1QWGjc8uJc5q/bxiOXpnFYl1Zxh1QrePWac87tgz++u5R/zMtk/Cn9OKl/WSNxuSKedJxzroJen7ueP767lPOGd+eaY/vEHU6t4knHOecqYM6arfz0hbmM7NWOX5810HuqVZAnHeecK6dVm3cybuJMDmjVmIcvGUbjVO+pVlGedJxzrhw278hj7BMzKDRj4hUjad/Ce6rtC++95pxzZdiZt5crJ85kY04uk68+goM6tog7pFrLk45zzpUiv6CQHzwziwXrc3jk0uEM7dk27pBqNa9ec865EpgZt740j38tyeKuMQM58TDvGr2/POk451wJ7n17MS/PWsePR/flwpE94w6nTvCk45xzSUz6eBUPf7Cci0f15MYTfdToyuJJxznninlzfiZ3vLGAk/p34ldn+rU4lcmTjnPOJfh0xRZunjKHYT3b8qeLhpLSwBNOZfKk45xzweIN27nqyXR6tG3KY2P9NgVVwZOOc84B67fuZuzjM2jWKIVJV46kTbNGcYdUJ3nScc7Ve1t37WHs4zPYmbeXiVeMpHvbZnGHVGeVK+lIelnS6ZI8STnn6pTc/OhGbKu37OKRy/y+OFWtvEnkL8DFwFJJ90g6tApjcs65alFQaNz03GzSV3/JAxcczpEHtY87pDqvXEnHzKaZ2feBYcAqYJqkjyVdIalhVQbonHNVwcy44/UFvL1gI788vT9nDO4ad0j1QrmryyS1By4HrgJmA38kSkJTqyQy55yrQn/5YDlPfbKaa4/tw5VH9447nHqjXAN+SnoFOBR4CviumWWGoimS0qsqOOecqwovpK/hd28v5qyh3bj1lH5xh1OvlPdM50Ez629mdyckHADMLK2iO5U0RdKc8FglaU6Y30vS7oSyCSWs307SVElLw9+2YX4/SdMl5Um6JWH5HpLel7RQ0gJJN1U0Zudc3fD+4k2Mf3k+xxzSgd+eM5gGfvFntSrvrQ3aSjq72LxtwHwz21TRnZrZBUXTku4P2yqy3MyGlLGJ8cC7ZnaPpPHh+a1ANnAjMKbY8nuBn5jZLEktgQxJU81sYUVjd87VXnPWbOWHT8/isC4tefiS4TRK9Q651a28SWcccCTwfnh+PJAB9JZ0p5k9tS87VzSg0fnACRVc9cwQA8Ak4APg1pAAN0k6PXHhcHaWGaa3S1oEdAM86ThXT6zcvJMrJ86kQ8tGPH75CFo09tuJxaG8ab4hcJiZnWNm5wD9AQNGEZ1h7KtjgI1mtjRhXm9JsyV9KOmYEtbrlFDNtwEo900uJPUChgKflrLMNZLSJaVnZWWVd9POuRoqa3selz0e/cs/eeUoDmjZJOaI6q/ypvruZrYx4fkmoIeZZUvKT7aCpGlA5yRFt5vZa2H6ImByQlkm0NPMtkgaDrwqaYCZ5ZQUmJmZJCvPQUhqAbwE3FzGNh8BHgFIS0sr17adczVT0WgDm7fvYfI1R9C7Q/O4Q6rXypt0PpD0d+CF8PycMK85sDXZCmY2urQNSkoFzgaGJ6yTB+SF6QxJy4G+QPEechsldTGzTEldiJJgqcL1RC8Bz5jZy2Ut75yr/XJy8xn7+AyWbdrBo2PTGNKjTdwh1XvlrV67HngCGBIeTwLXm9lOM/v2Pu57NPC5ma0tmiGpo6SUMN0HOARYkWTd14GxYXos8FqSZb4S2o4eAxaZ2QP7GK9zrhbZmbeXK5+YyYL1OTx8yTCO7dsx7pAc5TjTCUlgWkguL1Xivi/k61VrAMcCd4Yqu0LgOjPLDnE8Ckwws3TgHuB5SeOA1USdEZDUmeisqBVQKOlmovanwcClwPyi7tnAz83szUo8HudcDbF7TwHjJs1k9pqtPHTRUE48rNzNvq6KyazsJgtJ7wJnm9m2MheuY9LS0iw93a9/da62yNtbwFWT0vn3ss384YIhnDmkW9wh1TuSMkq6hrO8bTo7iM4SpgI7i2aa2Y2VEJ9zzlWKPXsLuf6ZWXy0dDP3njvYE04NVN6k83J4OOdcjbS3oJCbp8xm2qJN/GrMQM5P6xF3SC6JciUdM5skqSlRd+bFVRyTc85VSEGhccsLc3lz/gZ+cfphXHrEgXGH5EpQ3pu4fReYA7wVng+R9HpVBuacc+VRWGj8/OX5vDpnPT/9zqFcdUyfuENypShvl+k7gJGEa3LMbA7g76xzLlZmxh1vLGBK+hpuPOFgrv/2wXGH5MpQ3qSTn6TnWmFlB+Occ+VlZvzmzUU8OT26J86PT+obd0iuHMrbkWCBpIuBFEmHEI3k/HHVheWcc6V7YOoS/vbRSi4/qhfjT+1HdA24q+nKe6ZzAzCAaIiayUAOcHNVBeWcc6V56L2l/Om9ZVw0sgf/c0Z/Tzi1SHl7r+0Cbg8P55yLzd/+tYL73lnC2UO7cdeYQX4TtlqmvLer7gvcAvRKXMfMKnofHOec22dPTl/FXW8u4vTBXbj3XL/rZ21U3jadF4AJwKNAQdWF45xzyT034wv+57UFnNS/E3+4YAipKX7Xz9qovElnr5k9XKWROOdcCV6ZvZbbXpnPcX078tDFQ2noCafWKu8794akH0rqIqld0aNKI3POOeAf8zL5yfNzObJPe/566XAap6bEHZLbD+U90ym6d81PE+YZfoGoc64KTV24kZuem83wA9vy6Ng0mjT0hFPblbf3Wu+qDsQ55xJ9sHgT1z8ziwHdWvP45SNo1qi8v5FdTVZq9ZqknyVMn1es7DdVFZRzrn5767MNXPNkBgcf0IInrxhJyyYN4w7JVZKy2nQuTJi+rVjZKZUci3PO8crstVz/7CwGdGvF5KuPoHUzTzh1SVlJRyVMJ3vunHP75alPVvPjKXMZ1bsdT48b5QmnDiqrktRKmE723Dnn9tnDHyznt299zujDDuChi4d5p4E6qqykc7ikHKKzmqZhmvC8SZVG5pyrF8yM+95ZzJ/fX873Du/K/ecf7tfh1GGlJh0z858azrkqU1ho/N8bC5g0fTUXjezBr8cMIsWHtqnTvA+icy4WewsKufWl+bw0ay1XH9Obn592mI8WXQ940nHOVbu8vQXc/Nwc/vnZBv7fSX254YSDPeHUE550nHPVaveeAq59OoN/Lcnil2f0Z9zRfu15feJJxzlXbXJy87lqYjozV2fz23MGccGInnGH5KpZLF1EJE2RNCc8VkmaE+b3krQ7oWxCCeu3kzRV0tLwt22Y30/SdEl5km5Jsl6KpNmS/l61R+icKy575x6+/7dPmfXFlzx44VBPOPVULGc6ZnZB0bSk+4FtCcXLzWxIGZsYD7xrZvdIGh+e3wpkAzcCY0pY7yZgEdBqX2N3zlXcxpxcLnn0U77I3sUjlw3nhH6d4g7JxSTWzvCKWg7PByZXcNUzgUlhehIhyZjZJjObCeQn2Vd34HSiG9E556rJmuxdnDdhOuu37mbiFSM94dRzcV+BdQyw0cyWJszrHarAPpR0TAnrdTKzzDC9ASjPp/gPwM+AwrIWlHSNpHRJ6VlZWeXYtHMumWWbdnDehOls253PM1cfwZEHtY87JBezKqtekzQN6Jyk6HYzey1MX8TXz3IygazrJ2QAABqXSURBVJ5mtkXScOBVSQPMLOcbWwnMzCSVOiSPpDOATWaWIen4smI3s0eARwDS0tJ8uB/n9sFn67Zx2eMzaCAx5doj6NfZa7VdFSYdMxtdWrmkVOBsYHjCOnlAXpjOkLQc6AukF1t9o6QuZpYpqQuwqYxwvgV8T9JpRMP3tJL0tJldUqGDcs6VS/qqbK6YOJNWTRry9FWj6N2hedwhuRoizuq10cDnZra2aIakjpJSwnQf4BBgRZJ1X+e/dzMdC7yWZJmvmNltZtbdzHoR3a7hPU84zlWNj5ZmceljM+jQojHPX3ekJxz3NXFep3Mh3+xAcCxwp6R8oraX68wsG0DSo8AEM0sH7gGelzQOWE3UGQFJnYnOiloBhZJuBvqXVj3nnKs8b322gRsnz6ZPx+Y8NW4UHVs2jjskV8PIzJssSpOWlmbp6cVr95xzicyMRz9ayW/+uYghPdow8fKRfi+cekxShpmlJSvzEQmcc/slv6CQ/3ltAZNnfMFpgzpz/3lDaNrIB6h3yXnScc7ts2278/nhMxn8Z9kWrv/2QfzkpENp4LcmcKXwpOOc2yert+zkyokz+SJ7F/eddzjnDu8ed0iuFvCk45yrsJmrsrnmyXQMeGrcKI7o4xd9uvLxpOOcq5BXZq/l1hfn071tUx67fIR3iXYV4knHOVcuZsbvpy7hwfeWcUSfdky4ZDhtmjWKOyxXy3jScc6VKTe/gJ++OI835q7n/LTu/HrMIBqlxj10o6uNPOk450qVtT2Pa55KZ/YXWxl/aj+uPbaP31ra7TNPOs65Ei3esJ0rJ85ky848JlwyjFMGdok7JFfLedJxziX14ZIsrn9mFs0apfD8tUcyuHubuENydYAnHefcNzw1fRV3vLGQvp1a8vjlaXRp3TTukFwd4UnHOfeVgkLj1/9YyBP/WcWJ/Q7gwYuG0ryxf024yuOfJuccADvy9nLj5Nm89/kmxh3dm5+fdhgpPqSNq2SedJxzrNu6m3ETZ7J00w5+PWYglxxxYNwhuTrKk45z9dycNVu5alI6eXsLmHjFCI45pGPcIbk6zJOOc/WUmTHp41X85s3P6dS6MZOvHsUhnVrGHZar4zzpOFcPbduVz89emsvbCzYy+rAD+N25h9O2uQ9p46qeJx3n6pk5a7byo2dnsWFbLr84/TDGHd3bRxhw1caTjnP1hJnx2L9Xcs8/P6dTqya8cN2RDO3ZNu6wXD3jSce5emDrrj3c8sJcpi3axMn9O/G7cw+ndbOGcYfl6iFPOs7VcRmrs7nh2dls3rGHO77bn7FH9fLqNBcbTzrO1VGFhcYjH63gd28vplubprz0g6MY1L113GG5es6TjnN10JYdefzkhbl8sDiL0wd14e5zBtGqiVenufh50nGujpmxMpsbJs/iy135/GrMQC4Z1dOr01yN4UnHuTqisND4ywfLeGDqEg5s35zHLx/BgK5eneZqlljuNytpiqQ54bFK0pwwv5ek3QllE0pYv52kqZKWhr9tw/x+kqZLypN0S7F12kh6UdLnkhZJOrLqj9S56pG1PY+xT8zgvneWcMbgrrxxw9GecFyNFMuZjpldUDQt6X5gW0LxcjMbUsYmxgPvmtk9ksaH57cC2cCNwJgk6/wReMvMzpXUCGi2P8fgXE3x8fLN3PTcHHJ253PP2YO4YEQPr05zNVas1WuK/jPOB06o4KpnAseH6UnAB8CtZrYJ2CTp9GL7aQ0cC1wOYGZ7gD37GrdzNUFBofGn95by4LtL6d2hOU+NG0m/zq3iDsu5UsXdpnMMsNHMlibM6y1pNpAD/MLMPkqyXiczywzTG4BOZeynN5AFPCHpcCADuMnMdiZbWNI1wDUAPXv2LPfBOFddNuXkctNzc5i+YgtnD+vGr84c6Ddbc7VClX1KJU0DOicput3MXgvTFwGTE8oygZ5mtkXScOBVSQPMLKek/ZiZSbIywkkFhgE3mNmnkv5IVCX3yxK2+QjwCEBaWlpZ23au2pgZL2as5a43F5GbX8Dvzh3MeWk94g7LuXKrsqRjZqNLK5eUCpwNDE9YJw/IC9MZkpYDfYH0YqtvlNTFzDIldQE2lRHOWmCtmX0anr9IlHScqzVWbd7Jz1+Zz8fLtzCiV1vuPnswBx/QIu6wnKuQOM/HRwOfm9naohmSOgLZZlYgqQ9wCLAiybqvA2OBe8Lf15Is8xUz2yBpjaRDzWwxcCKwsJKOw7kqlV9QyCP/WsGD7y6lUUoD7jprIBeN6EkDv5W0q4XiTDoX8vWqNYga+++UlA8UAteZWTaApEeBCWaWTpRsnpc0DlhN1BkBSZ2JzopaAYWSbgb6h+q5G4BnQs+1FcAVVX2Azu2v2V98yW0vz+fzDds5dWBn7vjeADq1ahJ3WM7tM5l5k0Vp0tLSLD29eO2ec1VrR95e7nt7MZOmr6JTyybceeYATh6QrInUuZpHUoaZpSUr8+4uztUw7y7ayC9f/YzMnFwuO+JAbvnOobT0cdNcHeFJx7kaYtP2XP7vjYX8Y14mfTu14MWLj2L4gX6TNVe3eNJxLmaFhcbz6Wv4zZuLyN1byC0n9+WaYw+iUWoso1Q5V6U86TgXo+VZO7jt5fnMWJnNqN7tuPvsQfTp6N2gXd3lSce5GOzZW8iED5fz0HvLaNKwAb89ZxDnp/mYaa7u86TjXDXLWP0lt708jyUbd3DG4C78z3f7c0BL7wbt6gdPOs5Vk+25+dz71mKe/nQ1XVs35fHL0zihX1nDBjpXt3jSca6K5eYX8MynX/DwB8vI3rmHK47qzU9O7usDdLp6yT/1zlWRPXsLeT59DQ+9t4wNObl86+D23HpKPwZ3bxN3aM7FxpOOc5Vsb0Ehr85Zzx/fXcKa7N0MP7AtD1xwOEcd1CHu0JyLnScd5ypJYaHxj/mZ/H7aElZk7WRgt1bcecVAju/b0XulORd40nFuP5kZ0xZt4v53FvP5hu307dSCCZcM5zsDOnmyca4YTzrO7SMz49/LNnPfO0uYu2Yrvdo3448XDuGMwV1J8dsOOJeUJx3n9sGMldnc985iZqzMplubptx7zmDOHtaN1BQfusa50njSca4C5q7Zyv1Tl/CvJVl0bNmYO88cwAUjetA4NSXu0JyrFTzpOFcOizJzeGDqEqYu3EjbZg35+Wn9uPSIXjRt5MnGuYrwpONcKZZu3M6D7y3j7/PW06JxKj85qS9XHN2bFn5hp3P7xP9znCtm954C/jE/kykzv2Dmqi9p1iiFHx5/EFcf04c2zRrFHZ5ztZonHeeIeqJ9ti6H52Z+wetz1rM9by+9OzRn/Kn9OG94d9q3aBx3iM7VCZ50qsiNk2fTv2srzhrajU6tfAThmmrbrnxem7uO52asYWFmDo1TG3D6oC5cMKIHI3u38+tsnKtknnSqwM68vazfupvX567n3rc+57i+HTkvrQcnHnaA93KqAcyMT1dmM2XmGt6cn0ne3kIGdG3Fr8YM5HuHd6V104Zxh+hcnSUzizuGGi0tLc3S09P3ad2Vm3fyYsYaXspYx4acXNo0a8iZh3fl3OE9GNitlf+KrmabtufyUsY6nk9fw8rNO2nZJJUxQ7pxwYgeDOzWOu7wnKszJGWYWVrSMk86pdufpFOkoND4z7LNvJCxlrcXbGDP3kL6dW7JucO7M2ZoNzp4e0GV2VtQyL+WZvHcjDW8+/kmCgqNkb3bceGIHpw6sIt3eXauCnjS2Q+VkXQSbduVzxvz1vNCxlrmrtlKagPx7X4HcN7w7ny73wE09CvaK8Wa7F08n76GF9LXsiEnlw4tGnHO8O6cn9aDgzq2iDs85+o0Tzr7obKTTqIlG7fzUsZaXp69jqztebRv3ogxQ7tx7vDuHNalVZXss67K21vAnC+28vHyLXy8fDMzV31JA8FxfTtywYgenNCvE41SPaE7Vx1qXNKRNAU4NDxtA2w1syGSegGLgMWh7BMzuy7J+u2AKUAvYBVwvpl9Kakf8AQwDLjdzO5LWOfHwFWAAfOBK8wst6xYqzLpFNlbUMiHS7J4MWMt0xZtJL/AGNitFecN78H3Du9K2+Z+bUhxewsKmbduG9OXb2H68i2kr84mN78QCQZ2bc3owzpxXlp3urZpGneoztU7NS7pfC0A6X5gm5ndGZLO381sYBnr3Atkm9k9ksYDbc3sVkkHAAcCY4Avi5KOpG7Av4H+ZrZb0vPAm2Y2saz4qiPpJMreuYfX5qzjxYy1LFifQ6OUBozufwDfPvQADu/RhoM6tqiXIxgXFBqLMnP4ePlmpi/fwoyV2ezcUwBAv84tOfKg9hzZpz2jerendTPvfeZcnEpLOrF2mVbUfet84IQKrnomcHyYngR8ANxqZpuATZJOT7JOKtBUUj7QDFi/LzFXtXbNG3HFt3pzxbd6s3B9Di9mrOXVOet4c/4GAJo2TGFgt1YM6taGwd1bM7h7a3q1b06DOpaIzIwlG3d8lWQ+WbGFnNy9APTp2JyzhnXjqIM6MKp3O79w07laJNYzHUnHAg8UZcRwprMAWALkAL8ws4+SrLfVzNqEaRGd1bRJKL8D2FGseu0m4C5gN/COmX2/lLiuAa4B6Nmz5/DVq1fv34Hup8JCY8Xmncxbu5V5a7cxf902FqzfRm5+IQAtG6cysFuUgAZ1b83h3dvQvW3TWtUl28xYuXknHy/fwvQVW/hk+Ra27NwDQM92zTiyT/vobOag9n6xrXM1XCxnOpKmAZ2TFN1uZq+F6YuAyQllmUBPM9siaTjwqqQBZpZT0n7MzCSVmjkltSU6O+oNbAVekHSJmT1dwjYfAR6BqHqttG1XhwYNxMEHtODgA1pw9rDuQNSmsXTTDuav3ca8dVuZv3YbT/xnFXsKokTUpllDBhUlom5tOLxHazq3ahJbIsrNLyBzWy6ZW3dHf7ftZv22XDZsy2X91t2s37r7qzOZzq2acFzfjhwRqsx6tGsWS8zOucpXZUnHzEaXVi4pFTgbGJ6wTh6QF6YzJC0H+gLFG1U2SupiZpmSugCbyghnNLDSzLLCvl8GjgKSJp3aIDWlAYd1acVhXVpx/ogeQNSDa8mGHV8loblrtzHhwxUUFEZ5s0OLxgzu3prOrZvQrGEKTRuFR8MUmjVKoUnDFJo1SqVpKGuWWNYohWYNU5LepCw3v4CNObms3xolk6KkEiWUaPrLXfnfWK9d80Z0ad2E7m2bktarLYd1acVRB3WgV/tmteoszTlXfnG26YwGPjeztUUzJHUk6iBQIKkPcAiwIsm6rwNjgXvC39eSLJPoC+AISc2IqtdO5JuJrNZrnJrCoFDFxqhoXm5+AQszc0IS2spn67Yxb+1Wdu0pYHd+ARWtXW2Yoq+SUtOGKWzP3ftVNViiNs0a0qV1U7q0bsLQnm3o2qYpnVs1oUubJnRt3ZTOrZvQpKFfmOlcfRNn0rmQr1etARwL3Bka+wuB68wsG0DSo8AEM0snSjbPSxoHrCbqjICkzkTJpBVQKOlmoh5rn0p6EZgF7AVmE6rP6romDVMY1rMtw3q2/UaZmZG3t5DdewrYlV/A7j3hkV/Arj17yc0v+Co5FZXtKjbdonEqXVs3oXPrJnRtEyWZzq2b0KyRD+vnnPum2LtM13TV3WXaOedqu9I6Evgl2s4556qNJx3nnHPVxpOOc865auNJxznnXLXxpOOcc67aeNJxzjlXbTzpOOecqzaedJxzzlUbvzi0DJKyiEY92BcdgM2VGE5l8bgqxuOqGI+rYupiXAeaWcdkBZ50qpCk9JKuyo2Tx1UxHlfFeFwVU9/i8uo155xz1caTjnPOuWrjSadq1dSRrD2uivG4Ksbjqph6FZe36TjnnKs2fqbjnHOu2njScc45V2086ewDSY9L2iTpsxLKJelBScskzZM0LKFsrKSl4TG2JsQlaYik6ZIWhPkX1IS4EspbSVor6aGaEpeknpLekbRI0kJJvWpIXPeG93FRWEbVGFe/8DnKk3RLsbJTJC0OMY+vrJj2Jy5JPSS9H96/BZJuqglxJZSnSJot6e81JS5JbSS9KOnz8Bk7ssIBmJk/Kvgguq32MOCzEspPA/4JCDgC+DTMbwesCH/bhum2NSCuvsAhYborkAm0iTuuhPI/As8CD9WE9zGUfQCcFKZbAM3ijgs4CvgPkBIe04HjqzGuA4ARwF3ALQnzU4DlQB+gETCX6DbyccfVBRgWplsCS2pCXAnl/y987v9eWTHtb1zAJOCqMN1oX74n/ExnH5jZv4DsUhY5E3jSIp8AbSR1Ab4DTDWzbDP7EpgKnBJ3XGa2xMyWhm2sBzYBSa8mrs64ACQNBzoB71RWPPsbl6T+QKqZTQ3b2WFmu+KOCzCgCdGXQWOgIbCxuuIys01mNhPIL1Y0ElhmZivMbA/wXDiGWOMys0wzmxWmtwOLgG5xxwUgqTtwOvBoZcWzv3FJak2UsB4Ly+0xs60V3b8nnarRDViT8HxtmFfS/Ljj+oqkkURfWsvjjktSA+B+4BtVD9WkpNerL7BV0suh+uN3klLijsvMpgPvE52pZgJvm9miaoyrJHF/7ssUqkeHAp/GG8lX/gD8DCiMO5AEvYEs4InwuX9UUvOKbsSTjvtK+LX8FHCFmdWED/sPgTfNbG3cgRSTChxDlAxHEFUbXR5nQACSDgYOA7oTfamfIOmYeKOq+SS1AF4CbjaznBoQzxnAJjPLiDuWYlKJquUeNrOhwE6gwu1znnSqxjqgR8Lz7mFeSfPjjgtJrYB/ALeHKpvqVFJcRwI/krQKuA+4TNI9NSCutcCcUF20F3iV6J8x7rjOAj4J1X07iNp9Kt7QW/ni/tyXSFJDooTzjJm9HHc8wbeA74XP/XNEPx6ejjckIPrcrzWzorPBF9mHz70nnarxOtEXpCQdAWwzs0zgbeBkSW0ltQVODvNijUtSI+AVonaCF6sxnlLjMrPvm1lPM+tFdFbxpJlVas+nfYkLmEnUjlLU7nUCsLAGxPUFcJyk1PBlehxRO0XcZgKHSOodPmsXEh1DrELPvseARWb2QNzxFDGz28yse/jcXwi8Z2aXxBwWZrYBWCPp0DDrRPblc1+ZvSLqywOYTFRnnk+U/ccB1wHXhXIBfyZqF5kPpCWseyWwLDyuqAlxAZeEdeYkPIbEHVexbVxO5fde25/38SRgXpg/EWgUd1xEvcT+SpRoFgIPVPPr1TnMzwG2hulWoew0ot5hy4nOpmOPCziaqPPFvITP/Wlxx1VsG8dT+b3X9ud9HAKkh9fsVfah960Pg+Occ67aePWac865auNJxznnXLXxpOOcc67aeNJxzjlXbTzpOOecqzaedFytIalA0pwwIvBcST8JQ+UgKU3Sg6Ws20vSxdUXbflIujGM1vtMsfnHFx9dWNJESedWYNuXq5JH5q5sikY4Py3uOFz1SY07AOcqYLeZDQGQdADRCLytgP81s3Si6wdK0gu4OKxTk/wQGG3VONSPpFSLRlKoCYYAacCbcQfiqoef6bhaycw2AdcQDZOjxDMDSceFM6I5YWDClsA9wDFh3o/Dmc9HkmaFx1Fh3eMlfZBwz5BnwpXrSBoh6eNwljVDUktF9zz5naSZiu5tc22yeCX9P0mfhcfNYd4EonHb/inpx+U9dkknSHo14flJkl4J01dIWiJpBtFwKkXLTJQ0QdKnwL2S2kl6NcT8iaTBYbmOkqaGs8lHJa2W1CGUXRKOe46kvyoMcipph6S7wuvyiaROSWIeqegeLbPDa3hoGJ3gTuCCsM0LSonrDkmTwnu2WtLZiu4dNF/SW2EEBlcbVOaVrv7wR1U+gB1J5m0luvXB8YQrt4E3gG+F6RZEZ/RflYf5zYAmYfoQID1MHw9sIxofrAHRPWmOJhp5ewUwIizXKmz3GuAXYV5jorOt3sViHE40ckDzEM8CYGgoWwV0SHJcRXEkjhKRDZxLNCLB50DHsOyzwHeJ7g/zBdFtKRoR3VvnobDMRODvQEp4/ieiM0SIhvGZE6YfAm4L06cQXbHfgWgg0TeAhqHsL8BlYdqA74bpe4tej2LH04rodhAAo4GXwvTlJIw0UUpcdwD/Jrpdw+HALuDUUPYKMCbuz6c/yvfw6jVXF/0HeCC0k7xsZmv1zRtoNgQekjQEKCC6XUGRGRaquyTNIaqa2wZkWnSfESyMRizpZGBwQltLa6IktjJhe0cDr5jZzrDOy0SjVM8u4zg+MrMzip5Imhj2bZKeAi6R9ATRoJ6XAWcAH5hZVlh+SrHjesHMChJiOids7z1J7RUN+no00cChmNlbkr4My59IlDxnhteyKdF9lwD2ECU0gAyiIYKKaw1MknQIUZIq6cykpLgA/mlm+ZLmEw3581aYP5/oPXK1gCcdV2tJ6kOUMDYR/RIHwMzukfQPovG+/iPpO0lW/zHRDc4OJzqjyU0oy0uYLqD0/xMBN5hZdQ7cCvAE0ZlHLlEy2ZsksRa3cz/2J2CSmd2WpCzfwikHJb9evwLeN7OzFN275oN9iCEPwMwKJSXus7CEfboayNt0XK2kaITnCURVM1as7CAzm29mvyUa4bgfsJ3olsRFWhOduRQClxL9ci7NYqCLpBFhHy0lpRKNEv6DojYFSX31zRtbfQSMkdQslJ0V5u0zi+7wuh74BVECgugGZMeFs4OGwHmlbOIj4Psh5uOBzeHs7T/A+WH+yUS3VQd4FzhXUQcOQtvLgRUIuTX/vZ3B5Qnzi78vJcXl6gj/deBqk6ahuqshsJfohnPJhqS/WdK3iX4BLyC6r0whUCBpLlH7xl+AlyRdRlRNU+pZgJntkXQB8CdJTYHdRG0TjxJV7cwKHQ6ygDHF1p0VqsZmhFmPmllZVWvl8QxRu86isJ9MSXcQtUNtJWoHKskdwOOS5hG1j4wN8/8PmCzp0rCdDcB2M9ss6RfAO4q6qecD1wOryxnrvUTVa78gum9TkfeB8eF9vbuUuFwd4aNMO1dLKboGZ7aZPVaJ22wMFITquiOJ7hI5pLK275yf6ThXC0nKIDo7+0klb7on8Hw4m9kDXF3J23f1nJ/pOOecqzbekcA551y18aTjnHOu2njScc45V2086TjnnKs2nnScc85Vm/8PLJZbONtxN6oAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "pylab.plot(distances, energies)\n",
    "pylab.xlabel('Distance of Hydrogen atom')\n",
    "pylab.ylabel('Energy')\n",
    "pylab.title('H2O molecule, one H atom distance varied');"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
